// ImageProcessor.cpp
#include "preprocess.h"

// 构造函数：加载图像并初始化参数
ImageProcessor::ImageProcessor(const std::string& imagePath) {
    originalImage = cv::imread(imagePath);  // 从文件路径读取图像
    if (originalImage.empty()) {            // 检查图像是否加载成功
        throw std::runtime_error("无法加载图像");
    }
    
    // 创建椭圆结构元素用于形态学操作
    kernel = cv::getStructuringElement(cv::MORPH_ELLIPSE, cv::Size(morphSize, morphSize));
    defineColorRanges();  // 定义颜色范围
}

// 析构函数（空实现）
ImageProcessor::~ImageProcessor() {}

// 定义颜色检测范围（HSV空间）
void ImageProcessor::defineColorRanges() {
    // 黑色范围（低饱和度+低亮度）
    blackRanges = {{
        {cv::Scalar(0, 0, 0), cv::Scalar(180, 255, 50)}  // H(0-180), S(0-255), V(0-50)
    }};

    // 红色范围（HSV是环形空间，红色分布在0-10和160-180）
    redRanges = {{
        {cv::Scalar(0, 50, 50), cv::Scalar(10, 255, 255)},   // 红色区间1
        {cv::Scalar(160, 50, 50), cv::Scalar(180, 255, 255)} // 红色区间2
    }};
}

// 主处理流程
bool ImageProcessor::processImage() {
    try {
        convertToHSV();             // 转换到HSV颜色空间
        performColorSegmentation(); // 颜色分割
        performMorphologicalOperations(); // 形态学操作
        findAndFilterContours();    // 查找并过滤轮廓
        drawDetectionResults();     // 绘制检测结果
        createCropMask();           // 创建裁剪掩码
        return true;
    } catch (const std::exception& e) {
        std::cerr << "处理错误: " << e.what() << std::endl;
        return false;
    }
}

// 转换为HSV颜色空间
void ImageProcessor::convertToHSV() {
    cv::cvtColor(originalImage, hsvImage, cv::COLOR_BGR2HSV);
}

// 颜色分割（创建掩码）
void ImageProcessor::performColorSegmentation() {
    // 初始化三个通道的掩码（黑色、红色1、红色2）
    cv::Mat blackMask(hsvImage.size(), CV_8UC1, cv::Scalar(0));
    cv::Mat redMask1(hsvImage.size(), CV_8UC1, cv::Scalar(0));
    cv::Mat redMask2(hsvImage.size(), CV_8UC1, cv::Scalar(0));

    // 应用颜色范围生成掩码
    cv::inRange(hsvImage, blackRanges[0].lower, blackRanges[0].upper, blackMask);
    cv::inRange(hsvImage, redRanges[0].lower, redRanges[0].upper, redMask1);
    cv::inRange(hsvImage, redRanges[1].lower, redRanges[1].upper, redMask2);
    
    // 合并所有掩码（按位或操作）
    combinedMask = redMask1 | redMask2 | blackMask;
}

// 形态学操作（去噪+填充空洞）
void ImageProcessor::performMorphologicalOperations() {
    // 开运算：先腐蚀后膨胀，去除小噪点
    cv::morphologyEx(combinedMask, combinedMask, cv::MORPH_OPEN, kernel);
    // 闭运算：先膨胀后腐蚀，填充物体内部空洞
    cv::morphologyEx(combinedMask, combinedMask, cv::MORPH_CLOSE, kernel);
}

// 查找并过滤有效轮廓
void ImageProcessor::findAndFilterContours() {
    std::vector<std::vector<cv::Point>> contours;
    // 查找二值图像中的外部轮廓
    cv::findContours(combinedMask, contours, cv::RETR_EXTERNAL, cv::CHAIN_APPROX_SIMPLE);

    // 筛选有效轮廓（根据面积和宽高比）
    validContours.clear(); // 清空之前的轮廓
    for (const auto& contour : contours) {
        double area = cv::contourArea(contour);
        cv::Rect rect = cv::boundingRect(contour);
        double aspectRatio = static_cast<double>(rect.width) / rect.height;

        // 保留面积>200且宽高比在0.7-1.4之间的轮廓
        if (area > 200 && aspectRatio > 0.7 && aspectRatio < 1.4) {
            validContours.push_back(contour);
        }
    }

    // 更新掩码：仅保留有效轮廓区域
    combinedMask.setTo(cv::Scalar(0)); // 清空原有掩码
    cv::drawContours(combinedMask, validContours, -1, cv::Scalar(255), cv::FILLED);
}

// 绘制检测结果（只绘制最大轮廓）
void ImageProcessor::drawDetectionResults() {
    resultImage = originalImage.clone(); // 创建结果图像的副本
 
    // 初始化最大轮廓和最大面积
    std::vector<cv::Point> maxContour;
    double maxArea = 0.0;
 
    // 遍历所有有效轮廓以找到最大的轮廓
    for (const auto& contour : validContours) {
        double area = cv::contourArea(contour);
        if (area > maxArea) {
            maxArea = area;
            maxContour = contour;
        }
    }
 
    // 如果找到了最大轮廓，则绘制其轮廓和中心点
    if (!maxContour.empty()) {
        // 计算最大轮廓的矩（用于找中心点）
        cv::Moments m = cv::moments(maxContour);
        if (m.m00 != 0) { // 防止除以零
            // 计算中心点坐标
            cv::Point center(static_cast<int>(m.m10 / m.m00), static_cast<int>(m.m01 / m.m00));
            // 绘制绿色中心点
            cv::circle(resultImage, center, 5, cv::Scalar(0, 255, 0), -1);
        }
        // 绘制红色轮廓线（线宽2像素）
        cv::drawContours(resultImage, std::vector<std::vector<cv::Point>>{maxContour}, -1, cv::Scalar(0, 0, 255), 2);
    }
}
 
// 创建裁剪掩码并生成裁剪图像（只使用最大轮廓）
void ImageProcessor::createCropMask() {
    // 找到最大轮廓
    std::vector<cv::Point> maxContour;
    double maxArea = 0.0;
    for (const auto& contour : validContours) {
        double area = cv::contourArea(contour);
        if (area > maxArea) {
            maxArea = area;
            maxContour = contour;
        }
    }
 
    // 如果找到了最大轮廓，则创建裁剪掩码
    if (!maxContour.empty()) {
        // 创建全黑的掩码图像
        cv::Mat mask = cv::Mat::zeros(originalImage.size(), CV_8UC1);
        // 在掩码上绘制最大轮廓区域（白色填充）
        cv::drawContours(mask, std::vector<std::vector<cv::Point>>{maxContour}, -1, cv::Scalar(255), cv::FILLED);
        // 使用掩码裁剪原始图像
        cv::bitwise_and(originalImage, originalImage, croppedImage, mask);
    } else {
        // 如果没有找到最大轮廓，则裁剪图像为空
        croppedImage = cv::Mat();
    }
}

// 获取结果图像（带检测结果）
cv::Mat ImageProcessor::getResultImage() const {
    return resultImage;
}

// 获取裁剪后的图像
cv::Mat ImageProcessor::getCroppedImage() const {
    return croppedImage;
}
/*
int main() {

	
	try {
        ImageProcessor processor("黑车.jpg");
        
        if (processor.processImage()) {
            cv::imshow("原始图像", processor.getResultImage());
            cv::imshow("裁剪结果", processor.getCroppedImage());
            cv::waitKey(0);
        }
    } catch (const std::exception& e) {
        std::cerr << "错误: " << e.what() << std::endl;
        return -1;
    }
	
   
    return 0;
}
*/